﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <list>
#include <algorithm>
#include <string>
using namespace std;


// 2.list常用API

/*
list构造函数
list<T> lstT;//list采用采用模板类实现,对象的默认构造形式
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身
list(n,elem);//构造函数将n个elem拷贝给本身
list(const list& lst);//拷贝构造函数

list数据元素插入和删除操作
push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos);//删除pos位置的数据，返回下一个数据的位置
remove(elem);//删除容器中所有与elem值匹配的元素

list大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除

list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem);//将n个elem拷贝赋值给本身
list& operator=(const list& lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换

list数据的存取
front();//返回第一个元素
back();//返回最后一个元素

list反转排序
reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素
sort(); //list排序
*/
void printList(list<int>& L)
{
	for (list<int>::iterator it = L.begin(); it != L.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
bool myCompareList(int v1, int v2)
{
	//11.降序；
	return v1 > v2;
}
//13.自定义数据类型；
class PersonContainer
{
public:
	PersonContainer(string name, int age, int height)
	{
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}

	//17.重载==，让remove可以删除自定义的PersonContainer类型；
	bool operator==(const PersonContainer& p)const
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age && this->m_Height == p.m_Height)
		{
			return true;
		}
		return false;
	}

	string m_Name;
	int m_Age;
	int m_Height;//身高
};
//15.PersonContainer的排序规则；如果年龄相同，按照身高的升序排序；
bool myComparePerson(PersonContainer& p1, PersonContainer& p2)
{
	/*if (p1.m_Age > p2.m_Age)
	{
		return true;
	}
	return false;*/

	if (p1.m_Age == p2.m_Age)
	{
		return p1.m_Height < p2.m_Height;
	}
	else
	{
		return p1.m_Age > p2.m_Age;
	}
}
void testListContainer()
{
	//1.list是双向循环链表；视频里，使用的是SGI STL，我本地用Microsoft STL，后者里面没有实现循环，只有双向链表，
		//同时_Noteptr等变量也是private修饰，不允许直接访问。
	list<int> myList;
	for (int i = 0; i < 10; ++i)
	{
		myList.push_back(i);
	}
	//list<int>::_Nodeptr node = myList._Myhead->_Next;
	list<int>::iterator node = myList.begin();
	//for (int i = 0; i < myList._Mysize * 2; ++i)
	for (int i = 0; i < myList.size() * 2; ++i)
	{
		//cout << "Node: " << node->_Myval << endl;
		cout << "Node: " << *node << endl;//0, ... ,9,0, ... ,9
		//node = node->_Next;
		node++;
		//if (node == myList._Myhead)
		if (node == myList.end())
		{
			//node = node->_Next;
			node = myList.begin();
		}
	}

	list<int>L(10, 10);
	printList(L);//10 10 10 10 10 10 10 10 10 10
	list<int>L2(L.begin(), L.end());
	printList(L2);//10 10 10 10 10 10 10 10 10 10

	L2.push_back(100);
	//3.逆序打印；
	for (list<int>::reverse_iterator it = L2.rbegin(); it != L2.rend(); ++it)
	{
		cout << *it << " ";//100 10 10 10 10 10 10 10 10 10 10
	}
	cout << endl;

	//4.list迭代器不支持随机访问；
	list<int>::iterator itBegin = L2.begin();
	//itBegin = itBegin + 1;

	//5.插入数据；
	list<int> L3;
	L3.push_back(10);
	L3.push_back(30);
	L3.push_back(20);
	L3.push_front(100);
	L3.push_front(300);
	L3.push_front(200);

	printList(L3);//200 300 100 10 30 20

	//6.删除两端数据；
	L3.pop_front();//头删
	L3.pop_back();//尾删
	printList(L3);//300 100 10 30

	L3.insert(L3.begin(), 1000);
	printList(L3);//1000 300 100 10 30

	//7.remove(elem);//删除容器中所有与elem值匹配的元素
	L3.push_back(10);//1000 300 100 10 30 10
	//8.参数，直接放值；
	L3.remove(10);
	printList(L3);//1000 300 100 30

	cout << "L3大小：" << L3.size() << endl;//4
	if (L3.empty())
	{
		cout << "L3为空！" << endl;
	}
	else
	{
		cout << "L3不为空！" << endl;//L3不为空！
	}

	L3.resize(10);
	printList(L3);//1000 300 100 30 0 0 0 0 0 0

	L3.resize(3);
	printList(L3);//1000 300 100

	list<int> L4;
	L4.assign(L3.begin(), L3.end());

	cout << "L4的front：" << L4.front() << endl;//1000
	cout << "L4的back：" << L4.back() << endl;//100

	list<int> L5;
	L5.push_back(10);
	L5.push_back(20);
	L5.push_back(40);
	L5.push_back(30);

	L5.reverse();
	printList(L5);//30 40 20 10

	//9.所有不支持随机访问的迭代器，不可以用系统提供的算法；
	//sort(L5.begin(), L5.end());
	//10.如果不支持用系统提供的算法，那么这个类内部会提供；从小到大；
	L5.sort();
	printList(L5);//10 20 30 40

	//12.从大到小；
	L5.sort(myCompareList);
	printList(L5);//40 30 20 10

	list<PersonContainer> LP;
	PersonContainer p1("亚瑟", 10, 165);
	PersonContainer p2("德玛西亚", 20, 170);
	PersonContainer p3("金克斯", 17, 177);
	PersonContainer p4("鲁班大师", 19, 120);
	PersonContainer p5("狄仁杰", 18, 200);
	PersonContainer p6("狗蛋", 18, 166);
	PersonContainer p7("狗剩", 18, 210);

	LP.push_back(p1);
	LP.push_back(p2);
	LP.push_back(p3);
	LP.push_back(p4);
	LP.push_back(p5);
	LP.push_back(p6);
	LP.push_back(p7);

	//14.需求：打印数据的时候，按照年龄的降序输出；对于自定义数据类型，必须要指定降序规则；
	LP.sort(myComparePerson);

	for (list<PersonContainer>::iterator it = LP.begin(); it != LP.end(); ++it)
	{
		cout << "姓名：" << it->m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
	}
	/*姓名：德玛西亚 年龄：20
	姓名：鲁班大师 年龄：19
	姓名：狄仁杰 年龄：18
	姓名：金克斯 年龄：17
	姓名：亚瑟 年龄：10*/

	//-->

	/*姓名：德玛西亚 年龄：20 身高：170
	姓名：鲁班大师 年龄：19 身高：120
	姓名：狄仁杰 年龄：18 身高：200
	姓名：狗蛋 年龄：18 身高：166
	姓名：狗剩 年龄：18 身高：210
	姓名：金克斯 年龄：17 身高：177
	姓名：亚瑟 年龄：10 身高：165*/

	//-->

	/*姓名：德玛西亚 年龄：20 身高：170
	姓名：鲁班大师 年龄：19 身高：120
	姓名：狗蛋 年龄：18 身高：166
	姓名：狄仁杰 年龄：18 身高：200
	姓名：狗剩 年龄：18 身高：210
	姓名：金克斯 年龄：17 身高：177
	姓名：亚瑟 年龄：10 身高：165*/

	cout << "-------------------------------------" << endl;
	//16.删除狗剩；
	LP.remove(p7);
	for (list<PersonContainer>::iterator it = LP.begin(); it != LP.end(); ++it)
	{
		cout << "姓名：" << it->m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
	}
	/*姓名：德玛西亚 年龄：20 身高：170
	姓名：鲁班大师 年龄：19 身高：120
	姓名：狗蛋 年龄：18 身高：166
	姓名：狄仁杰 年龄：18 身高：200
	姓名：金克斯 年龄：17 身高：177
	姓名：亚瑟 年龄：10 身高：165*/
}

//main325：list集合容器
int main325()
{
	testListContainer();

	system("pause");
	return EXIT_SUCCESS;
}